Failed to generate code suggestions for PR

there are some conflicts that need to be resolved, thanks

Conflicts resolved

Rebased onto current main. Here's a summary of the conflict resolution, particularly around volcengine_vlm.py which had the most significant changes.

Background

Two upstream commits landed after this PR was branched:

• ce99887 — License change Apache-2.0 → AGPL-3.0 (touched all file headers)
• a66a1a6 — Refactor memory extract v2 (Refactor memory extract v2 #1045) + VolcEngine Responses API with prefix caching

The license conflicts were trivial (accept upstream). The interesting part is how retry integrates with the new VolcEngine architecture.

volcengine_vlm.py — Retry + Responses API

Before (old architecture): VolcEngine used client.chat.completions.create() directly. Our retry wrapped that call:

async def _call():
    return await client.chat.completions.create(**kwargs)
response = await transient_retry_async(_call, max_retries=self.max_retries)

After (new architecture): Upstream refactored to use VolcEngine Responses API with prefix caching via responseapi_prefixcache_completion(). Sync methods now delegate through run_async().

Resolution: Retry wraps the high-level responseapi_prefixcache_completion call:

async def _call():
    return await self.responseapi_prefixcache_completion(
        static_segments=static_segments,
        dynamic_messages=dynamic_messages,
        response_format=response_format,
        tools=tools,
        tool_choice=tool_choice,
    )
response = await transient_retry_async(_call, max_retries=self.max_retries)

Why this is safe:

• Retry is placed at the same abstraction level — around the API call, before response processing
• Prefix cache is deterministic (same input → same cache key), so retries won't cause cache inconsistency
• Sync methods (get_completion, get_vision_completion) delegate to async via run_async(), so they inherit retry automatically
• get_vision_completion_async delegates to get_completion_async, so vision also gets retry
• Only transient_retry_async is imported (removed unused transient_retry since sync paths use run_async)

memory_react.py — Accepted deletion

Upstream deleted this file in #1045. Our branch had modified the get_completion_async call to pass max_retries=. Since retry is now config-driven and max_retries was removed from the signature, this change is no longer needed. Accepted the deletion.

Other files

• openai_vlm.py, llm.py, vlm_config.py — straightforward: accepted upstream formatting/license, applied our kwargs migration and retry on top
• openai_embedders.py — kept both imports (transient_retry + DEFAULT_AZURE_API_VERSION)

Test results

All 84 tests from this PR pass. No regressions introduced (the 71 pre-existing failures on main are unchanged).

For context, we have also been working on a very similar implementation in parallel in #926.

Functionally, the direction is the same: move retry down to the model layer, make it config-driven, and apply it consistently across VLM and embedding instead of adding more call-site wrappers.

The main differences vs our in-flight branch are:

• feat: unify config-driven retry across VLM and embedding #1049 lands the broad VLM + embedding unification and the config contract directly in one PR;
• our branch also centralizes transient-error classification in a shared utility and reuses the same classification in the circuit-breaker path, so retry and breaker behavior stay aligned;
• our current test coverage emphasis is a bit different, with some extra config/wiring and integration-path verification around the surrounding call flow.

Our follow-up plan on our side is to converge on a single bottom-layer retry implementation rather than keep two parallel versions, keep the config-driven contract as the baseline, and only carry forward the pieces that still add value on top of #1049 (for example shared classifier reuse and any targeted behavior/test gaps we find).